﻿using System;
using System.Collections.Generic;
using System.ServiceModel.Activation;
using LASLogic.BusinessLayer.BusinessLogic;
using LASLogic.BusinessLayer.DataModel;
using LASLogic.BusinessLayer.Utilities;

namespace LASGui.Web
{
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class SilverlightService : Contracts.IMainServiceSilverlight
    {
        #region User Operations

        /// <summary>
        /// Registra un usuario en la aplicación. Si ya está registrado, ignora el método.
        /// </summary>
        /// <param name="user">Información del usuario a registrar</param>
        /// <returns>Devuelve si se pudo registrar o revisar que el usuario estuviera en el sistema</returns>
        public bool InsertNewUser(LasUser user)
        {
            return UserManager.GetInstance().InsertNewUser(user);
        }

        /// <summary>
        /// Obtiene un usuario a partir de un md5
        /// </summary>
        /// <param name="md5">MD5 que representa el codigo del usuario</param>
        /// <returns>Usuario de la base de datos, null si no existe</returns>
        public LasUser GetUser(string md5)
        {
            return UserManager.GetInstance().GetUser(md5);
        }

        /// <summary>
        /// Verifica si el login del usuario es valido, es decir no existen otros con el mismo login
        /// </summary>
        /// <param name="login">Usuario con su login</param>
        /// <returns>Bool indicando si es valido o no</returns>
        public bool ValidUser(string login)
        {
            return UserManager.GetInstance().ValidUser(login);
        }

        /// <summary>
        /// Metodo que permite obtener una dirección a partir de un identificador de usuario
        /// </summary>
        /// <returns>Direccion que se deseaba obtener</returns>
        public Address GetAddress(int userId)
        {
            return UserManager.GetInstance().GetAddress(userId);
        }

        #endregion


        #region FinantialOperations

        /// <summary>
        /// Inserta un nuevo asiento en el libro finaciero de la compañía
        /// </summary>
        /// <param name="entry">Asiento que se desea agregar en el libro financiero de la compañía</param>
        /// <returns>Booleano que indica si el asiento se insertó bien, true para insertado, false para lo contrario</returns>
        public bool InsertEntry(Entry entry)
        {
            return FinancialManager.GetInstance().InsertEntry(entry);
        }

        /// <summary>
        /// Permite borrar un asiento de la base de datos generando un contra asiento al asiento especificado
        /// </summary>
        /// <param name="entryId">Identificador del asiento a borrar</param>
        /// <returns>Estado del borrado del asiento</returns>
        public bool EraseEntry(int entryId)
        {
            return FinancialManager.GetInstance().EraseEntry(entryId);
        }

        /// <summary>
        /// Permite obtener todos los asientos de una compañia en particular y acotado por fechas
        /// </summary>
        /// <param name="companyId">Identificador de una compañia</param>
        /// <param name="startDate">Fecha que marca el inicio de donde se quieren traer asientos</param>
        /// <param name="endDate">Fecha que marca el final de donde se quieren traer fechas</param>
        /// <returns>Obtiene todos los asientos de una compañia</returns>
        public List<Entry> GetEntriesFromCompany(int companyId, DateTime startDate, DateTime endDate)
        {
            return FinancialManager.GetInstance().GetEntriesFromCompany(companyId, startDate, endDate);
        }


        /// <summary>
        /// Permite insertar una nueva cuenta dentro del libro financiero de la compañia
        /// </summary>
        /// <param name="account">Cuenta la cual se quiere insertar en la compañia</param>
        /// <returns>Booleano indicando el estado de la inserción</returns>
        public bool InsertNewAccount(Account account)
        {
            return FinancialManager.GetInstance().InsertNewAccount(account);
        }

        /// <summary>
        /// Metodo que permite cambiar el estado de una cuenta
        /// </summary>
        /// <param name="accountId">Id de la cuenta</param>
        /// <param name="status">Nuevo estado de la cuenta</param>
        public bool ChangeAccountStatus(int accountId, string status)
        {
            return FinancialManager.GetInstance().ChangeAccountStatus(accountId, status);
        }


        /// <summary>
        /// Permite borrar una cuenta del catálogo de cuentas
        /// </summary>
        /// <param name="accountId">Identificador de la cuenta a borrar</param>
        /// <returns>Booleano indicando el estado del borrado</returns>
        public bool EraseAccount(int accountId)
        {
            return FinancialManager.GetInstance().EraseAccount(accountId);
        }

        /// <summary>
        /// Permite obtener el catalogo de cuentas de una compañia
        /// </summary>
        /// <param name="companyId">Identificador de la compañia la cual se quiere obtener el catálogo</param>
        /// <returns>El catálogo de la compañia</returns>
        public AccountCatalog GetAccountingCatalog(int companyId)
        {
            return FinancialManager.GetInstance().GetAccountingCatalog(companyId);
        }


        /// <summary>
        /// Permite insertar el catalogo de cuentas de una compañia
        /// </summary>
        /// <param name="companyId">Identificador de la compañia la cual se quiere insertar el catálogo</param>
        /// <returns>El id del catalogo contable</returns>
        public int InsertAccountingCatalog(int companyId)
        {
            return FinancialManager.GetInstance().InsertAccountingCatalog(companyId);
        }



        /// <summary>
        /// Permite insertar un nuevo período de tiempo para una tasa de cambio
        /// </summary>
        /// <param name="companyId">Identificador de la compañia la cual se quiere insertar el catálogo</param>
        /// <param name="currencyIdDestiny">Identificador de la moneda correspondiente a la tasa de cambio</param>
        /// <param name="startDate">Fecha inicial en la que estará vigente el tipo de cambio</param>
        /// <param name="finishDate">Fecha final en la que estará vigente el tipo de cambio</param>
        /// <param name="exchangeRate">Valor del tipo de cambio</param>
        /// <param name="currencyIdBegining"></param>
        /// <returns>El id del catalogo contable</returns>
        public bool InsertExchangeRate(int companyId, int currencyIdBegining, int currencyIdDestiny, DateTime startDate, DateTime finishDate,
                                      decimal exchangeRate)
        {
            return FinancialManager.GetInstance().InsertExchangeRate(companyId, currencyIdBegining, currencyIdDestiny, startDate, finishDate,
                                                                     exchangeRate);
        }


        /// <summary>
        /// Permite obtener los estados para un pais
        /// </summary>
        /// <param name="companyId">Identificador de la compania</param>
        /// <param name="currencyIdBegining">Nombre de la moneda que se quiere obtener el tipo de cambio</param>
        /// <param name="currencyIdDestiny">Nombre de la moneda destino que se quiere obtener el tipo de cambio</param>
        /// <param name="fechaActual">Fecha que se quiere averiguar el tipo de cambio de las monedas</param>
        /// <returns>Retorna una lista de estados</returns>
        public decimal GetExchangeRate(int companyId, int currencyIdBegining, int currencyIdDestiny, DateTime fechaActual)
        {
            return FinancialManager.GetInstance().GetExchangeRate(companyId, currencyIdBegining,
                                                                  currencyIdDestiny, fechaActual);
        }

        /// <summary>
        /// Permite obtener todas las monedas de la base de datos
        /// </summary>
        /// <returns>Lista de monedas de la base de datos</returns>
        public List<Currency> GetCurrencies()
        {
            return FinancialManager.GetInstance().GetCurrencies();
        }


        /// <summary>
        /// Permite insertar una nueva moneda
        /// </summary>
        /// <param name="currency">Moneda a insertar</param>
        /// <returns>Si se logró efectuar correctamente</returns>
        public bool InsertCurrency(Currency currency)
        {
            return FinancialManager.GetInstance().InsertCurrency(currency);
        }


        /// <summary>
        /// Metodo que permite insertar un periodo contable para una compañía
        /// </summary>
        /// <param name="companyId">Identificador de la compañia</param>
        /// <param name="accountingPeriod">Periodo a insertar</param>
        public bool InsertAccountingPeriod(int companyId, AccountingPeriod accountingPeriod)
        {
            return FinancialManager.GetInstance().InsertAccountingPeriod(companyId, accountingPeriod);
        }


        /// <summary>
        /// Permite cambiar la moneda a una cuenta
        /// </summary>
        /// <param name="accountId">identificador de la cuenta</param>
        /// <param name="currencyName">nombre de la moneda</param>
        /// <returns>Booleano si se cambia la moneda</returns>
        public bool ChangeAccountCurrency(int accountId, string currencyName)
        {
            return FinancialManager.GetInstance().ChangeAccountCurrency(accountId, currencyName);
        }

        /// <summary>
        /// Permite cambiar la información de una cuenta
        /// </summary>
        /// <param name="account">Cuenta a ser modificada</param>
        /// <returns>Booleano si se cambia la moneda</returns>
        public bool ChangeAccountInformation(Account account)
        {
            return FinancialManager.GetInstance().ChangeAccountInformation(account);
        }

        #endregion

        #region Company Operations

        /// <summary>
        /// Inserta una nueva compañia en la aplicación.
        /// </summary>
        /// <param name="company">Compañia a insertar dentro de la aplicación</param>
        /// <returns>Retorna true si la compañia se insertó, false para lo contrario</returns>
        public bool InsertNewCompany(Company company)
        {
            return CompanyManager.GetInstance().InsertNewCompany(company);
        }

        /// <summary>
        /// Obtiene una compañia del sistema
        /// </summary>
        /// <param name="companyId">Identificador de la compañía</param>
        /// <returns>Compañia que se quiere obtener</returns>
        public Company GetCompany(int companyId)
        {
            return CompanyManager.GetInstance().GetCompany(companyId);
        }

        /// <summary>
        /// Permite obtener todas las compañias del sistema
        /// </summary>
        /// <returns>Lista de compañias que se encuentran en el sistema</returns>
        public List<Company> GetCompanies()
        {
            return CompanyManager.GetInstance().GetCompanies();
        }


        /// <summary>
        /// Método que permite obtener el balance de comprobacion de una empresa
        /// </summary>
        /// <param name="companyId"></param>
        /// <param name="tipoDeMoneda"></param>
        /// <returns>Compañia que se desea obtener el balance</returns>
        public string GetBalanceDeComprobacion(int companyId, string tipoDeMoneda)
        {
            return CompanyManager.GetInstance().GetBalanceDeComprobacion(companyId, tipoDeMoneda);
        }

        /// <summary>
        /// Método que permite obtener el balance de comprobacion de una empresa
        /// </summary>
        /// <param name="companyId">IdCompañia</param>
        /// <param name="tipoDeMoneda">Selecciona la moneda en que se quiere el resultado</param>
        /// <returns>Compañia que se desea obtener el balance</returns>
        public string GetEstadoResultados(int companyId, string tipoDeMoneda)
        {
            return CompanyManager.GetInstance().GetEstadoResultados(companyId, tipoDeMoneda);
        }

        /// <summary>
        /// Método que permite obtener el estado de resultados de una empresa
        /// </summary>
        /// <param name="companyId">Identificador de la compañía</param>
        /// <param name="tipoDeMoneda">Tipo de moneda</param>
        /// <returns>Compañia que se desea obtener el estado de resultados</returns>
        public string GetBalanceGeneral(int companyId, string tipoDeMoneda)
        {
            return CompanyManager.GetInstance().GetBalanceGeneral(companyId, tipoDeMoneda);
        }

        /// <summary>
        /// Permite obtener las monedas de una compañia
        /// </summary>
        /// <param name="companyId">identificador de la compañia</param>
        /// <returns>Las Monedas de una compañia</returns>
        public List<Currency> GetCompanyCurrencies(int companyId)
        {
            return CompanyManager.GetInstance().GetCompanyCurrencies(companyId);
        }

        /// <summary>
        /// Permite añadir telefonos a una compañia
        /// </summary>
        /// <param name="phone">Objeto telefono</param>
        /// <param name="companyId">Id de la empresa</param>
        /// <returns>Retorna true si el telefono se insertó, false para lo contrario</returns>
        public bool AddPhonesToCompany(Phone phone, int companyId)
        {
            return CompanyManager.GetInstance().AddPhonesToCompany(phone, companyId);
        }

        /// <summary>
        /// Método que permite obtener todos los periodos contables de una compañia
        /// </summary>
        /// <param name="periodId">Indentificador del periodo</param>
        /// <returns>Compañia que se deseaba obtener</returns>
        public List<AccountingMonth> GetAccountingMonths(int periodId)
        {
            return CompanyManager.GetInstance().GetAccountingMonths(periodId);
        }

        /// <summary>
        /// Método que permite obtener todos los periodos contables de una compañia
        /// </summary>
        /// <param name="companyId">Identificador de la compañía</param>
        /// <returns>Periodos contables de la compañía</returns>
        public List<AccountingPeriod> GetAccountingPeriods(int companyId)
        {
            return CompanyManager.GetInstance().GetAccountingPeriods(companyId);
        }

        /// <summary>
        /// Permite cambiar el estado de un mes contable a otro
        /// </summary>
        /// <param name="monthId">mes al que se le quiere cambiar el estado</param>
        /// <param name="monthStatus">estado que se convertira en el nuevo mes</param>
        /// <returns>Booleano indicando el estado de la operacion realizada</returns>
        public bool ChangeMonthStatus(int monthId, string monthStatus)
        {
            return CompanyManager.GetInstance().ChangeMonthStatus(monthId, monthStatus);
        }

        /// <summary>
        /// Permite obtener todas las ciudades de un estado
        /// </summary>
        /// <returns>Lista de ciudades de un estado</returns>
        public List<City> GetCities(int stateId)
        {
            return CompanyManager.GetInstance().GetCities(stateId);
        }

        /// <summary>
        /// Permite obtener los estados para un pais
        /// </summary>
        /// <param name="paisId">Compañia a insertar dentro de la aplicación</param>
        /// <returns>Retorna una lista de estados</returns>
        public List<State> GetStates(int paisId)
        {
            return CompanyManager.GetInstance().GetStates(paisId);
        }


        /// <summary>
        /// Permite obtener los paises
        /// </summary>
        /// <returns>Lista de los paises</returns>
        public List<Country> GetCountries()
        {
            return CompanyManager.GetInstance().GetCountries();
        }

        #endregion

        #region Misc Operations

        /// <summary>
        /// Permite obtener las constantes del sistema de ser necesarias
        /// </summary>
        /// <returns>Constantes del sistema</returns>
        public Constants GetConstants()
        {
            return new Constants();
        }

        #endregion
    }
}
